package graph;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
/**
 * 题目描述
 *
 * 在象棋中，马和象的移动规则分别是“马走日”和“象走田”。现给定骑士的起始坐标和目标坐标，要求根据骑士的移动规则，计算从起点到达目标点所需的最短步数。
 * 骑士移动规则如图，红色是起始位置，黄色是骑士可以走的地方。
 * 棋盘大小 1000 x 1000（棋盘的 x 和 y 坐标均在 [1, 1000] 区间内，包含边界）
 * 输入描述
 * 第一行包含一个整数 n，表示测试用例的数量。
 * 接下来的 n 行，每行包含四个整数 a1, a2, b1, b2，分别表示骑士的起始位置 (a1, a2) 和目标位置 (b1, b2)。
 * 输出描述
 * 输出共 n 行，每行输出一个整数，表示骑士从起点到目标点的最短路径长度。
 */
public class A{
    public static int a1;
    public static int a2;
    public static int b1;
    public static int b2;
    public static int[][] dir = new int[][]{{-2,1}, {-2,-1}, {-1,2}, {-1, -2}, {1,2}, {1,-2}, {2,1}, {2,-1}};
    public static int[][] dp;

    public static class Node{
        int x; // x of this node
        int y; // y of this node
        int g; // distance from source to this node
        int h; // distance from this node to destination
        int f; // the weight of this node

        public Node(int x, int y, int g, int h) {
            this.x = x;
            this.y = y;
            this.g = g;
            this.h = h;
            this.f = g + h;
        }
    }

    public static void main(String[] args) {
        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            @Override
            public int compare(Node a, Node b) {
                return Integer.compare(a.f, b.f); // want to reach 0, smaller f has higher priority
            }
        });


        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        for (int i=0; i<n; i++) {
            dp = new int[1001][1001];

            a1 = sc.nextInt();
            a2 = sc.nextInt();
            b1 = sc.nextInt();
            b2 = sc.nextInt();

            Node start = new Node(a1, a2, 0, getRemainDist(a1, a2));
            pq.add(start);
            while(!pq.isEmpty()) {
                Node curNode = pq.remove();
                if (curNode.x==b1 && curNode.y==b2) break;

                for (int j=0; j<8; j++) { // totally 8 different directions
                    int x = curNode.x + dir[j][0];
                    int y = curNode.y + dir[j][1];
                    if (x<1 || x>1000 || y<1 || y>1000) continue;

                    if (dp[x][y] == 0) {
                        dp[x][y] = dp[curNode.x][curNode.y] + 1; // dp formula
                        Node nextNode = new Node(x, y, curNode.g+5, getRemainDist(x, y));
                        pq.add(nextNode);
                    }
                }
            }
            System.out.println(dp[b1][b2]);
            pq.clear();
        }
    }

    public static int getRemainDist(int x, int y) {
        return (x-b1)*(x-b1) + (y-b2)*(y-b2);
    }
}
